/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_Studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"


#ifdef _DEBUG 
//#ifdef NDDEBUG 
#pragma comment(lib, "D:/U/DEV/OpenCV_SDK/lib/Debug/opencv_core430d.lib")
#pragma comment(lib, "D:/U/DEV/OpenCV_SDK/lib/Debug/opencv_tracking430d.lib")
#pragma comment(lib, "D:/U/DEV/OpenCV_SDK/lib/Debug/opencv_imgproc430d.lib")
#pragma comment(lib, "D:/U/DEV/OpenCV_SDK/lib/Debug/opencv_features2d430d.lib")
//#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Debug/opencv_video430d.lib")
//#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Debug/opencv_videoio430d.lib")
//#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Debug/opencv_objdetect430d.lib")
//#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Debug/opencv_world430d.lib")

#else

#pragma comment(lib, "D:/U/DEV/OpenCV_SDK/lib/Release/opencv_core430.lib")
#pragma comment(lib, "D:/U/DEV/OpenCV_SDK/lib/Release/opencv_tracking430.lib")
#pragma comment(lib, "D:/U/DEV/OpenCV_SDK/lib/Release/opencv_imgproc430.lib")
#pragma comment(lib, "D:/U/DEV/OpenCV_SDK/lib/Release/opencv_features2d430.lib")


/*#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_core430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_tracking430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_video430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_videoio430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_objdetect430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_aruco430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_bgsegm430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_bioinspired430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_calib3d430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_ccalib430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_datasets430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_dnn_objdetect430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_dnn_superres430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_dnn430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_dpm430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_face430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_features2d430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_flann430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_fuzzy430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_gapi430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_hfs430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_highgui430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_img_hash430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_imgcodecs430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_imgproc430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_intensity_transform430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_line_descriptor430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_ml430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_objdetect430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_optflow430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_phase_unwrapping430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_photo430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_plot430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_quality430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_rapid430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_reg430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_rgbd430.lib")

#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_saliency430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_shape430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_stereo430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_stitching430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_structured_light430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_superres430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_surface_matching430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_text430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_video430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_videoio430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_videostab430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_ximgproc430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_xobjdetect430.lib")
#pragma comment(lib, "D:/DEV/OpenCV_SDK/lib/Release/opencv_xphoto430.lib")*/


#endif





#include "node后端.h"
#include "节点/socket_utils.h"

#include <JIT.h>

#include <future>
#include <Windows.h>
#include <mutex>
#include <文件/file_载入保存数据.h>


#include "节点/数据/数值变量.h"
#include "节点/数据/数据重组.h"
#include "节点/数据/字符文本.h"
#include "节点/数据/变量类JIT函数.h"

#include "节点/逻辑/执行节点.h"
#include "节点/逻辑/单节点脚本.h"

#include "节点/网格/几何网格.h"
#include "节点/网格/网格修改.h"

#include "节点/计算/单数值计算.h"
#include "节点/计算/矢量计算.h"
#include "节点/计算/矩阵节点.h"
#include "节点/计算/点集几何计算.h"
#include "节点/计算/计算类JIT函数.h"

#include "节点/空间/场景信息.h"
#include "节点/空间/OpenVDB.h"

#include "节点/物体/动画点.h"
#include "节点/物体/物体节点.h"
#include "节点/物体/拾取.h"
#include "节点/物体/蒙皮骨骼.h"
#include "节点/物体/灯光节点.h"
#include "节点/物体/物体类JIT函数.h"

#include "节点/材质/材质节点.h"
#include "节点/材质/纹理节点.h"
#include "节点/材质/材质纹理JIT函数绑定.h"
#include "节点/网络/UDP.h"
#include "节点/调试/信息视图.h"

#include "节点/物理/粒子发射器.h"
#include "节点/物理/物理体.h"
#include "节点/物理/物理力.h"
#include "节点/物理/解算器.h"


#include "节点/动画/非线性动画条.h"
#include "节点/容器节点/空间分割.h"
#include "节点/容器节点/数据缓存.h"


#include "节点/渲染/渲染节点.h"


#include "Context/当前默认操作数据.h"
#include "Context/数据创建销毁.h"
#include "异步解算/物理异步解算.h"







static std::mutex g添加删除锁;
static bool g是否运行节点树 = false;

std::thread	g节点运行线程;



static std::vector<C_Widget*> g暂停绘制部件;





static std::map<std::string, fp_创建节点函数> g_节点创建函数;
static std::map<std::string, fp_加载节点函数> g_节点加载函数;
static std::map<std::string, fp_保存节点函数> g_节点保存函数;

static S_纹理* g渲染器默认纹理 = nullptr;
static S_纹理* g渲染器默认字符纹理 = nullptr;
static S_材质* g渲染器默认材质 = nullptr;


void f_node_环境初始化() {
	f_init_JTI();

	//std::wstring path_hone = L"C:/ProgramData/Anaconda3";
	//std::wstring path_hone = L"D:/U/DEV/Python38";
	//std::wstring ProgramName = L"C:/ProgramData/Anaconda3/python.exe";
	//std::wstring path_lib = L"C:/ProgramData/Anaconda3/Lib";
	
	//Py_SetProgramName(path_lib.c_str());
	//Py_SetPythonHome(path_hone.c_str());
	//auto pName = PyString_FromString("");
	//Py_SetPath(path_lib.c_str());
	//Py_Initialize();
	//std::string path = "sys.path.append('C:/ProgramData/Anaconda3/Lib/')";
	//PyRun_SimpleString(path.c_str());


	WSADATA wsaData;
	if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0) {
		printf("初始化失败.\n");
		return;
	}

	/* ============= 变量 ============= */
	g_节点创建函数[DEF_变量引用节点] = f_node_创建变量引用节点;
	g_节点加载函数[DEF_变量引用节点] = f_node_加载变量引用节点;
	g_节点保存函数[DEF_变量引用节点] = f_node_保存变量引用节点;

	g_节点创建函数[DEF_I8变量节点] = f_node_创建I8变量节点;
	g_节点加载函数[DEF_I8变量节点] = f_node_加载I8变量节点;
	g_节点保存函数[DEF_I8变量节点] = f_node_保存I8变量节点;

	g_节点创建函数[DEF_浮点变量节点] = f_node_创建单值浮点变量节点;
	g_节点加载函数[DEF_浮点变量节点] = f_node_加载单值浮点变量节点;
	g_节点保存函数[DEF_浮点变量节点] = f_node_保存单值浮点变量节点;

	g_节点创建函数[DEF_整数变量节点] = f_node_创建单值整数变量节点;
	g_节点加载函数[DEF_整数变量节点] = f_node_加载单值整数变量节点;
	g_节点保存函数[DEF_整数变量节点] = f_node_保存单值整数变量节点;

	g_节点创建函数[DEF_无符号整数变量节点] = f_node_创建无符号整数变量节点;
	g_节点加载函数[DEF_无符号整数变量节点] = f_node_加载无符号整数变量节点;
	g_节点保存函数[DEF_无符号整数变量节点] = f_node_保存无符号整数变量节点;

	g_节点创建函数[DEF_vec2变量节点] = f_node_创建vec2变量节点;
	g_节点加载函数[DEF_vec2变量节点] = f_node_加载vec2变量节点;
	g_节点保存函数[DEF_vec2变量节点] = f_node_保存vec2变量节点;

	g_节点创建函数[DEF_vec3变量节点] = f_node_创建vec3变量节点;
	g_节点加载函数[DEF_vec3变量节点] = f_node_加载vec3变量节点;
	g_节点保存函数[DEF_vec3变量节点] = f_node_保存vec3变量节点;

	g_节点创建函数[DEF_ivec3变量节点] = f_node_创建ivec3变量节点;
	g_节点加载函数[DEF_ivec3变量节点] = f_node_加载ivec3变量节点;
	g_节点保存函数[DEF_ivec3变量节点] = f_node_保存ivec3变量节点;

	g_节点创建函数[DEF_线段变量节点] = f_node_创建线段数据节点;
	g_节点加载函数[DEF_线段变量节点] = f_node_加载线段数据节点;
	g_节点保存函数[DEF_线段变量节点] = f_node_保存线段数据节点;

	g_节点创建函数[DEF_I8数组变量节点] = f_node_创建I8数组变量节点;
	g_节点加载函数[DEF_I8数组变量节点] = f_node_加载I8数组变量节点;
	g_节点保存函数[DEF_I8数组变量节点] = f_node_保存I8数组变量节点;

	g_节点创建函数[DEF_vec2数组变量节点] = f_node_创建vec2数组变量节点;
	g_节点加载函数[DEF_vec2数组变量节点] = f_node_加载vec2数组变量节点;
	g_节点保存函数[DEF_vec2数组变量节点] = f_node_保存vec2数组变量节点;
	
	g_节点创建函数[DEF_vec3数组变量节点] = f_node_创建vec3数组变量节点;
	g_节点加载函数[DEF_vec3数组变量节点] = f_node_加载vec3数组变量节点;
	g_节点保存函数[DEF_vec3数组变量节点] = f_node_保存vec3数组变量节点;

	g_节点创建函数[DEF_ivec2数组变量节点] = f_node_创建ivec2数组变量节点;
	g_节点加载函数[DEF_ivec2数组变量节点] = f_node_加载ivec2数组变量节点;
	g_节点保存函数[DEF_ivec2数组变量节点] = f_node_保存ivec2数组变量节点;

	g_节点创建函数[DEF_ivec3数组变量节点] = f_node_创建ivec3数组变量节点;
	g_节点加载函数[DEF_ivec3数组变量节点] = f_node_加载ivec3数组变量节点;
	g_节点保存函数[DEF_ivec3数组变量节点] = f_node_保存ivec3数组变量节点;

	g_节点创建函数[DEF_Vec4数组变量节点] = f_node_创建Vec4数组节点;
	g_节点加载函数[DEF_Vec4数组变量节点] = f_node_加载Vec4数组节点;
	g_节点保存函数[DEF_Vec4数组变量节点] = f_node_保存Vec4数组节点;

	g_节点创建函数[DEF_I32数组变量节点] = f_node_创建区间数组变量节点;
	g_节点加载函数[DEF_I32数组变量节点] = f_node_加载区间数组变量节点;
	g_节点保存函数[DEF_I32数组变量节点] = f_node_保存区间数组变量节点;

	g_节点创建函数[DEF_UI32数组变量节点] = f_node_创建UI32数组变量节点;
	g_节点加载函数[DEF_UI32数组变量节点] = f_node_加载UI32数组变量节点;
	g_节点保存函数[DEF_UI32数组变量节点] = f_node_保存UI32数组变量节点;

	g_节点创建函数[DEF_F32数组变量节点] = f_node_创建浮点数组变量节点;
	g_节点加载函数[DEF_F32数组变量节点] = f_node_加载浮点数组变量节点;
	g_节点保存函数[DEF_F32数组变量节点] = f_node_保存浮点数组变量节点;

	g_节点创建函数["vec球数组节点"] = f_node_创建vec球数组节点;
	g_节点加载函数["vec球数组节点"] = f_node_加载vec球数组节点;
	g_节点保存函数["vec球数组节点"] = f_node_保存vec球数组节点;

	g_节点创建函数[DEF_坐标构建平面变量节点] = f_node_创建坐标构建平面节点;
	g_节点加载函数[DEF_坐标构建平面变量节点] = f_node_加载坐标构建平面节点;
	g_节点保存函数[DEF_坐标构建平面变量节点] = f_node_保存坐标构建平面节点;

	g_节点创建函数[DEF_线段1D变量节点] = f_node_创建线段1D变量节点;
	g_节点加载函数[DEF_线段1D变量节点] = f_node_加载线段1D数据节点;
	g_节点保存函数[DEF_线段1D变量节点] = f_node_保存线段1D数据节点;

	g_节点创建函数[DEF_观察矩阵构建节点] = f_node_创建观察矩阵构建节点;
	g_节点加载函数[DEF_观察矩阵构建节点] = f_node_加载观察矩阵构建节点;
	g_节点保存函数[DEF_观察矩阵构建节点] = f_node_保存观察矩阵构建节点;

	g_节点创建函数[DEF_44矩阵数组变量节点] = f_node_创建矩阵数组变量节点;
	g_节点加载函数[DEF_44矩阵数组变量节点] = f_node_加载矩阵数组变量节点;
	g_节点保存函数[DEF_44矩阵数组变量节点] = f_node_保存矩阵数组变量节点;

	g_节点创建函数[DEF_数组变量节点] = f_node_创建数组变量节点;
	g_节点加载函数[DEF_数组变量节点] = f_node_加载数组变量节点;
	g_节点保存函数[DEF_数组变量节点] = f_node_保存数组变量节点;

	g_节点创建函数[DEF_添加数组元素节点] = f_node_创建数组添加元素节点;
	g_节点加载函数[DEF_添加数组元素节点] = f_node_加载数组添加元素节点;
	g_节点保存函数[DEF_添加数组元素节点] = f_node_保存数组添加元素节点;

	g_节点创建函数[DEF_取数组属性节点] = f_node_创建取数组属性节点;
	g_节点加载函数[DEF_取数组属性节点] = f_node_加载取数组属性节点;
	g_节点保存函数[DEF_取数组属性节点] = f_node_保存取数组属性节点;

	g_节点创建函数[DEF_取数组元素节点] = f_node_创建取数组元素节点;
	g_节点加载函数[DEF_取数组元素节点] = f_node_加载取数组元素节点;
	g_节点保存函数[DEF_取数组元素节点] = f_node_保存取数组元素节点;

	g_节点创建函数[DEF_取数组头尾元素节点] = f_node_创建取末尾数组元素节点;
	g_节点加载函数[DEF_取数组头尾元素节点] = f_node_加载取末尾数组元素节点;
	g_节点保存函数[DEF_取数组头尾元素节点] = f_node_保存取末尾数组元素节点;

	g_节点创建函数[DEF_插入数组节点] = f_node_创建插入数组节点;
	g_节点加载函数[DEF_插入数组节点] = f_node_加载插入数组节点;
	g_节点保存函数[DEF_插入数组节点] = f_node_保存插入数组节点;

	g_节点创建函数[DEF_查找数组元素节点] = f_node_创建查找数组元素节点;
	g_节点加载函数[DEF_查找数组元素节点] = f_node_加载查找数组元素节点;
	g_节点保存函数[DEF_查找数组元素节点] = f_node_保存查找数组元素节点;

	g_节点创建函数[DEF_删除数组元素节点] = f_node_创建删除数组元素节点;
	g_节点加载函数[DEF_删除数组元素节点] = f_node_加载删除数组元素节点;
	g_节点保存函数[DEF_删除数组元素节点] = f_node_保存删除数组元素节点;

	g_节点创建函数[DEF_从坐标取数据节点] = f_node_创建从坐标取数据节点;
	g_节点加载函数[DEF_从坐标取数据节点] = f_node_加载从坐标取数据节点;
	g_节点保存函数[DEF_从坐标取数据节点] = f_node_保存从坐标取数据节点;

	g_节点加载函数["数据缓存写入节点"] = f_node_加载写入数据缓存节点;
	g_节点保存函数["数据缓存写入节点"] = f_node_保存写入数据缓存节点;

	g_节点加载函数["数据缓存读取节点"] = f_node_加载数据缓存读取节点;
	g_节点保存函数["数据缓存读取节点"] = f_node_保存数据缓存读取节点;

	g_节点创建函数[DEF_单值钳制节点] = f_node_创建单值钳制节点;
	g_节点加载函数[DEF_单值钳制节点] = f_node_加载单值钳制节点;
	g_节点保存函数[DEF_单值钳制节点] = f_node_保存单值钳制节点;

	g_节点创建函数[DEF_取内存邻接数据节点] = f_node_创建取内存邻接数据节点;
	g_节点加载函数[DEF_取内存邻接数据节点] = f_node_加载取内存邻接数据节点;
	g_节点保存函数[DEF_取内存邻接数据节点] = f_node_保存取内存邻接数据节点;

	g_节点创建函数[DEF_取空间邻接数据节点] = f_node_创建取空间邻接数据节点;
	g_节点加载函数[DEF_取空间邻接数据节点] = f_node_加载取空间邻接数据节点;
	g_节点保存函数[DEF_取空间邻接数据节点] = f_node_保存取空间邻接数据节点;

	g_节点创建函数[DEF_合并数组元素节点] = f_node_创建合并数组元素节点;
	g_节点加载函数[DEF_合并数组元素节点] = f_node_加载合并数组元素节点;
	g_节点保存函数[DEF_合并数组元素节点] = f_node_保存合并数组元素节点;

	g_节点创建函数[DEF_复制数组节点] = f_node_创建复制数组节点;
	g_节点加载函数[DEF_复制数组节点] = f_node_加载复制数组节点;
	g_节点保存函数[DEF_复制数组节点] = f_node_保存复制数组节点;

	g_节点创建函数[DEF_矢量钳制节点] = f_node_创建矢量钳制节点;
	g_节点加载函数[DEF_矢量钳制节点] = f_node_加载矢量钳制节点;
	g_节点保存函数[DEF_矢量钳制节点] = f_node_保存矢量钳制节点;

	g_节点创建函数[DEF_数组元素统计节点] = f_node_创建数组元素统计节点;
	g_节点加载函数[DEF_数组元素统计节点] = f_node_加载数组元素统计节点;
	g_节点保存函数[DEF_数组元素统计节点] = f_node_保存数组元素统计节点;

	g_节点创建函数[DEF_索引数组排序节点] = f_node_创建索引数组排序节点;
	g_节点加载函数[DEF_索引数组排序节点] = f_node_加载索引数组排序节点;
	g_节点保存函数[DEF_索引数组排序节点] = f_node_保存索引数组排序节点;

	g_节点创建函数[DEF_数组重排节点] = f_node_创建数组重排节点;
	g_节点加载函数[DEF_数组重排节点] = f_node_加载数组重排节点;
	g_节点保存函数[DEF_数组重排节点] = f_node_保存数组重排节点;

	g_节点创建函数[DEF_数组打乱节点] = f_node_创建数组打乱节点;
	g_节点加载函数[DEF_数组打乱节点] = f_node_加载数组打乱节点;
	g_节点保存函数[DEF_数组打乱节点] = f_node_保存数组打乱节点;

	g_节点创建函数[DEF_数组抽取节点] = f_node_创建数组抽取节点;
	g_节点加载函数[DEF_数组抽取节点] = f_node_加载数组抽取节点;
	g_节点保存函数[DEF_数组抽取节点] = f_node_保存数组抽取节点;

	g_节点创建函数[DEF_多边形成员数组变量节点] = f_node_创建多边形成员数组变量节点;
	g_节点加载函数[DEF_多边形成员数组变量节点] = f_node_加载多边形成员数组变量节点;
	g_节点保存函数[DEF_多边形成员数组变量节点] = f_node_保存多边形成员数组变量节点;


	g_节点创建函数[DEF_文件路径节点] = f_node_创建文件路径节点;
	g_节点加载函数[DEF_文件路径节点] = f_node_加载文件路径节点;
	g_节点保存函数[DEF_文件路径节点] = f_node_保存文件路径节点;

	g_节点创建函数[DEF_行字符串变量节点] = f_node_创建行字符串变量节点;
	g_节点加载函数[DEF_行字符串变量节点] = f_node_加载行字符串变量节点;
	g_节点保存函数[DEF_行字符串变量节点] = f_node_保存行字符串变量节点;

	g_节点创建函数[DEF_数值转字符串节点] = f_node_创建数值转字符串节点;
	g_节点加载函数[DEF_数值转字符串节点] = f_node_加载数值转字符串节点;
	g_节点保存函数[DEF_数值转字符串节点] = f_node_保存数值转字符串节点;

	g_节点创建函数[DEF_合并字符串节点] = f_node_创建合并字符串节点;
	g_节点加载函数[DEF_合并字符串节点] = f_node_加载合并字符串节点;
	g_节点保存函数[DEF_合并字符串节点] = f_node_保存合并字符串节点;




	/* ============= 计算 ============= */
	g_节点创建函数[DEF_回写节点] = f_node_创建回写节点;
	g_节点加载函数[DEF_回写节点] = f_node_加载回写节点;
	g_节点保存函数[DEF_回写节点] = f_node_保存回写节点;

	g_节点创建函数[DEF_逻辑计算节点] = f_node_创建逻辑计算节点;
	g_节点加载函数[DEF_逻辑计算节点] = f_node_加载逻辑计算节点;
	g_节点保存函数[DEF_逻辑计算节点] = f_node_保存逻辑计算节点;

	g_节点创建函数[DEF_单目计算节点] = f_node_创建单目计算节点;
	g_节点加载函数[DEF_单目计算节点] = f_node_加载单目计算节点;
	g_节点保存函数[DEF_单目计算节点] = f_node_保存单目计算节点;

	g_节点创建函数[DEF_单值计算节点] = f_node_创建单值计算节点;
	g_节点加载函数[DEF_单值计算节点] = f_node_加载单值计算节点;
	g_节点保存函数[DEF_单值计算节点] = f_node_保存单值计算节点;

	g_节点创建函数[DEF_累计计算节点] = f_node_创建累计计算节点;
	g_节点加载函数[DEF_累计计算节点] = f_node_加载累计计算节点;
	g_节点保存函数[DEF_累计计算节点] = f_node_保存累计计算节点;

	g_节点创建函数[DEF_位运算节点] = f_node_创建位运算节点;
	g_节点加载函数[DEF_位运算节点] = f_node_加载位运算节点;
	g_节点保存函数[DEF_位运算节点] = f_node_保存位运算节点;


	g_节点创建函数[DEF_矢量计算节点] = f_node_创建矢量计算节点;
	g_节点加载函数[DEF_矢量计算节点] = f_node_加载矢量计算节点;
	g_节点保存函数[DEF_矢量计算节点] = f_node_保存矢量计算节点;

	g_节点创建函数[DEF_几何计算节点] = f_node_创建几何计算节点;
	g_节点加载函数[DEF_几何计算节点] = f_node_加载几何计算节点;
	g_节点保存函数[DEF_几何计算节点] = f_node_保存几何计算节点;

	g_节点创建函数["矩阵变换节点"] = f_node_创建矩阵变换节点;
	g_节点加载函数["矩阵变换节点"] = f_node_加载矩阵变换节点;
	g_节点保存函数["矩阵变换节点"] = f_node_保存矩阵变换节点;

	g_节点创建函数["矩阵计算节点"] = f_node_创建矩阵计算节点;
	g_节点加载函数["矩阵计算节点"] = f_node_加载矩阵计算节点;
	g_节点保存函数["矩阵计算节点"] = f_node_保存矩阵计算节点;

	g_节点创建函数[DEF_顶点变换节点] = f_node_创建顶点变换节点;
	g_节点加载函数[DEF_顶点变换节点] = f_node_加载顶点变换节点;
	g_节点保存函数[DEF_顶点变换节点] = f_node_保存顶点变换节点;

	g_节点创建函数[DEF_合并XYZ节点] = f_node_创建合并XYZ节点;
	g_节点加载函数[DEF_合并XYZ节点] = f_node_加载合并XYZ节点;
	g_节点保存函数[DEF_合并XYZ节点] = f_node_保存合并XYZ节点;

	g_节点创建函数[DEF_分离XYZ节点] = f_node_创建分离XYZ节点;
	g_节点加载函数[DEF_分离XYZ节点] = f_node_加载分离XYZ节点;
	g_节点保存函数[DEF_分离XYZ节点] = f_node_保存分离XYZ节点;

	g_节点创建函数[DEF_混合计算节点] = f_node_创建混合节点;
	g_节点加载函数[DEF_混合计算节点] = f_node_加载混合节点;
	g_节点保存函数[DEF_混合计算节点] = f_node_保存混合节点;

	g_节点创建函数[DEF_设置矢量分量节点] = f_node_创建矢量分量节点;
	g_节点加载函数[DEF_设置矢量分量节点] = f_node_加载矢量分量节点;
	g_节点保存函数[DEF_设置矢量分量节点] = f_node_保存矢量分量节点;

	g_节点创建函数["矩阵构建节点"] = f_node_创建矩阵构建节点;
	g_节点加载函数["矩阵构建节点"] = f_node_加载矩阵构建节点;
	g_节点保存函数["矩阵构建节点"] = f_node_保存矩阵构建节点;

	g_节点创建函数[DEF_平面到点节点] = f_node_创建平面向量节点;
	g_节点加载函数[DEF_平面到点节点] = f_node_加载平面向量节点;
	g_节点保存函数[DEF_平面到点节点] = f_node_保存平面向量节点;

	g_节点创建函数[DEF_矩阵转换节点] = f_node_创建旋转矩阵转欧拉角节点;
	g_节点加载函数[DEF_矩阵转换节点] = f_node_加载旋转矩阵转欧拉角节点;
	g_节点保存函数[DEF_矩阵转换节点] = f_node_保存旋转矩阵转欧拉角节点;

	g_节点创建函数[DEF_两向量转四元数] = f_node_创建向量转四元数节点;
	g_节点加载函数[DEF_两向量转四元数] = f_node_加载向量转四元数节点;
	g_节点保存函数[DEF_两向量转四元数] = f_node_保存向量转四元数节点;

	g_节点创建函数[DEF_四元数计算节点] = f_node_创建四元数计算节点;
	g_节点加载函数[DEF_四元数计算节点] = f_node_加载四元数计算节点;
	g_节点保存函数[DEF_四元数计算节点] = f_node_保存四元数计算节点;

	g_节点创建函数[DEF_四元变换节点] = f_node_创建四元数变换节点;
	g_节点加载函数[DEF_四元变换节点] = f_node_加载四元数变换节点;
	g_节点保存函数[DEF_四元变换节点] = f_node_保存四元数变换节点;

	g_节点创建函数[DEF_向量角度组成四元数节点] = f_node_创建向量角度组成四元数节点;
	g_节点加载函数[DEF_向量角度组成四元数节点] = f_node_加载向量角度组成四元数节点;
	g_节点保存函数[DEF_向量角度组成四元数节点] = f_node_保存向量角度组成四元数节点;

	g_节点创建函数[DEF_四元数转换为欧拉角节点] = f_node_创建四元数转换为欧拉角节点;
	g_节点加载函数[DEF_四元数转换为欧拉角节点] = f_node_加载四元数转换为欧拉角节点;
	g_节点保存函数[DEF_四元数转换为欧拉角节点] = f_node_保存四元数转换为欧拉角节点;

	g_节点创建函数[DEF_四元数转换为4X4矩阵节点] = f_node_创建四元数转换为矩阵节点;
	g_节点加载函数[DEF_四元数转换为4X4矩阵节点] = f_node_加载四元数转换为矩阵节点;
	g_节点保存函数[DEF_四元数转换为4X4矩阵节点] = f_node_保存四元数转换为矩阵节点;




	g_节点加载函数["顶点变换节点"] = f_node_加载顶点变换节点;
	g_节点保存函数["顶点变换节点"] = f_node_保存顶点变换节点;

	g_节点创建函数[DEF_射线物体相交节点] = f_node_创建射线物体相交节点;
	g_节点加载函数[DEF_射线物体相交节点] = f_node_加载射线物体相交节点;
	g_节点保存函数[DEF_射线物体相交节点] = f_node_保存射线物体相交节点;

	g_节点加载函数["点集转变换节点"] = f_node_加载点集约束到变换节点;
	g_节点保存函数["点集转变换节点"] = f_node_保存点集约束到变换节点;

	g_节点创建函数[DEF_圆坐标生成节点] = f_node_创建圆坐标生成节点;
	g_节点加载函数[DEF_圆坐标生成节点] = f_node_加载圆坐标生成节点;
	g_节点保存函数[DEF_圆坐标生成节点] = f_node_保存圆坐标生成节点;

	g_节点创建函数[DEF_直线坐标生成节点] = f_node_创建直线坐标生成节点;
	g_节点加载函数[DEF_直线坐标生成节点] = f_node_加载直线坐标生成节点;
	g_节点保存函数[DEF_直线坐标生成节点] = f_node_保存直线坐标生成节点;

	g_节点创建函数[DEF_渐变采样节点] = f_node_创建渐变采样节点;
	g_节点加载函数[DEF_渐变采样节点] = f_node_加载渐变采样节点;
	g_节点保存函数[DEF_渐变采样节点] = f_node_保存渐变采样节点;

	g_节点创建函数[DEF_三角函数节点] = f_node_创建三角函数计算节点;
	g_节点加载函数[DEF_三角函数节点] = f_node_加载三角函数计算节点;
	g_节点保存函数[DEF_三角函数节点] = f_node_保存三角函数计算节点;

	g_节点创建函数[DEF_归一化节点] = f_node_创建向量归一化节点;
	g_节点加载函数[DEF_归一化节点] = f_node_加载向量归一化节点;
	g_节点保存函数[DEF_归一化节点] = f_node_保存向量归一化节点;

	g_节点创建函数[DEF_两向量标量计算节点] = f_node_创建计算标量节点;
	g_节点加载函数[DEF_两向量标量计算节点] = f_node_加载计算标量节点;
	g_节点保存函数[DEF_两向量标量计算节点] = f_node_保存计算标量节点;

	g_节点创建函数[DEF_向量标量计算节点] = f_node_创建单向量标量节点;
	g_节点加载函数[DEF_向量标量计算节点] = f_node_加载单向量标量节点;
	g_节点保存函数[DEF_向量标量计算节点] = f_node_保存单向量标量节点;

	g_节点创建函数[DEF_旋转向量节点] = f_node_创建旋转向量节点;
	g_节点加载函数[DEF_旋转向量节点] = f_node_加载旋转向量节点;
	g_节点保存函数[DEF_旋转向量节点] = f_node_保存旋转向量节点;

	g_节点创建函数[DEF_按轴向旋转向量节点] = f_node_创建按轴向旋转向量节点;
	g_节点加载函数[DEF_按轴向旋转向量节点] = f_node_加载按轴向旋转向量节点;
	g_节点保存函数[DEF_按轴向旋转向量节点] = f_node_保存按轴向旋转向量节点;

	g_节点创建函数[DEF_绕点旋转节点] = f_node_创建绕点旋转节点;
	g_节点加载函数[DEF_绕点旋转节点] = f_node_加载绕点旋转节点;
	g_节点保存函数[DEF_绕点旋转节点] = f_node_保存绕点旋转节点;

	g_节点创建函数[DEF_平面线段相交节点] = f_node_创建线段平面相交节点;
	g_节点加载函数[DEF_平面线段相交节点] = f_node_加载线段平面相交节点;
	g_节点保存函数[DEF_平面线段相交节点] = f_node_保存线段平面相交节点;

	g_节点创建函数[DEF_坐标转索引节点] = f_node_创建坐标转索引节点;
	g_节点加载函数[DEF_坐标转索引节点] = f_node_加载坐标转索引节点;
	g_节点保存函数[DEF_坐标转索引节点] = f_node_保存坐标转索引节点;

	g_节点创建函数[DEF_索引转坐标节点] = f_node_创建索引转坐标节点;
	g_节点加载函数[DEF_索引转坐标节点] = f_node_加载索引转坐标节点;
	g_节点保存函数[DEF_索引转坐标节点] = f_node_保存索引转坐标节点;

	g_节点创建函数[DEF_步进计算节点] = f_node_创建步进计算节点;
	g_节点加载函数[DEF_步进计算节点] = f_node_加载步进计算节点;
	g_节点保存函数[DEF_步进计算节点] = f_node_保存步进计算节点;




	/* ================================ 容器 ================================== */
	g_节点加载函数["点距八叉树节点"] = f_node_载入点距八叉树节点;
	g_节点保存函数["点距八叉树节点"] = f_node_保存点距八叉树节点;

	g_节点加载函数["转换数据节点"] = f_node_加载转换数据节点;
	g_节点保存函数["转换数据节点"] = f_node_保存转换数据节点;
	g_节点加载函数["取成员数据节点"] = f_node_加载取成员数据节点;
	g_节点保存函数["取成员数据节点"] = f_node_保存取成员数据节点;

	g_节点创建函数[DEF_合并数据节点]    = f_node_创建合并数据节点;
	g_节点加载函数[DEF_合并数据节点]    = f_node_加载合并数据节点;
	g_节点保存函数[DEF_合并数据节点]    = f_node_保存合并数据节点;

	g_节点加载函数["手动执行节点"]		= f_node_加载手动执行节点;

	g_节点加载函数["记录点节点"] = f_node_加载记录点节点;

	//g_节点创建函数["转换数据节点"] = f_node_加载转换数据节点;
	//g_节点保存函数["转换数据节点"] = f_node_保存转换数据节点;
	//g_节点创建函数["取成员数据节点"]		= f_node_加载取成员数据节点;
	//g_节点保存函数["取成员数据节点"]		= f_node_保存取成员数据节点;

	g_节点加载函数["流视频节点"]		= f_node_加载流视频节点;
	g_节点加载函数["UDP接收节点"]		= f_node_UDP接收节点;
	g_节点加载函数["UDP接收图像节点"]	= f_node_UDP接收图像节点;

	g_节点创建函数[DEF_物体缓存节点] = f_node_创建物体缓存节点;
	g_节点加载函数[DEF_物体缓存节点] = f_node_加载物体缓存节点;
	g_节点保存函数[DEF_物体缓存节点] = f_node_保存物体缓存节点;

	g_节点创建函数[DEF_网格缓存写入节点] = f_node_创建网格缓存写入节点;
	g_节点加载函数[DEF_网格缓存写入节点] = f_node_加载网格缓存写入节点;
	g_节点保存函数[DEF_网格缓存写入节点] = f_node_保存网格缓存写入节点;

	g_节点创建函数[DEF_读取网格缓存节点] = f_node_创建读取网格缓存节点;
	g_节点加载函数[DEF_读取网格缓存节点] = f_node_加载读取网格缓存节点;
	g_节点保存函数[DEF_读取网格缓存节点] = f_node_保存读取网格缓存节点;


	/* ========================== 网格 ========================= */
	g_节点创建函数[DEF_网格节点] = f_node_创建网格节点;
	g_节点加载函数[DEF_网格节点] = f_node_载入网格节点;
	g_节点保存函数[DEF_网格节点] = f_node_保存网格节点;

	g_节点创建函数["球体网格生成节点"] = f_node_创建球体网格节点;
	g_节点加载函数["球体网格生成节点"] = f_node_载入球体网格节点;
	g_节点保存函数["球体网格生成节点"] = f_node_保存球体网格节点;

	g_节点创建函数["矩形网格生成节点"] = f_node_创建矩形网格节点;
	g_节点加载函数["矩形网格生成节点"] = f_node_载入矩形网格节点;
	g_节点保存函数["矩形网格生成节点"] = f_node_保存矩形网格节点;

	g_节点创建函数["平面网格节点"] = f_node_创建平面网格节点;
	g_节点加载函数["平面网格节点"] = f_node_载入平面网格节点;
	g_节点保存函数["平面网格节点"] = f_node_保存平面网格节点;

	g_节点创建函数["线框立方体节点"] = f_node_创建线框立方体节点;
	g_节点加载函数["线框立方体节点"] = f_node_载入线框立方体节点;
	g_节点保存函数["线框立方体节点"] = f_node_保存线框立方体节点;

	g_节点创建函数[DEF_几何节点] = f_node_创建几何节点;
	g_节点加载函数[DEF_几何节点] = f_node_载入几何节点;
	g_节点保存函数[DEF_几何节点] = f_node_保存几何节点;

	g_节点创建函数[DEF_几何ID节点] = f_node_创建几何ID节点;
	g_节点加载函数[DEF_几何ID节点] = f_node_加载几何ID节点;
	g_节点保存函数[DEF_几何ID节点] = f_node_保存几何ID节点;

	g_节点创建函数[DEF_当前多边形节点] = f_node_创建当前多边形节点;
	g_节点加载函数[DEF_当前多边形节点] = f_node_加载当前多边形节点;
	g_节点保存函数[DEF_当前多边形节点] = f_node_保存当前多边形节点;

	g_节点创建函数[DEF_基本多边形节点] = f_node_创建基本多边形节点;
	g_节点加载函数[DEF_基本多边形节点] = f_node_载入基本多边形节点;
	g_节点保存函数[DEF_基本多边形节点] = f_node_保存基本多边形节点;

	g_节点创建函数["网格体素节点"] = f_node_创建网格体素节点;
	g_节点加载函数["网格体素节点"] = f_node_载入网格体素节点;
	g_节点保存函数["网格体素节点"] = f_node_保存网格体素节点;

	g_节点创建函数["网格采样节点"] = f_node_创建网格采样节点;
	g_节点加载函数["网格采样节点"] = f_node_载入网格采样节点;
	g_节点保存函数["网格采样节点"] = f_node_保存网格采样节点;

	g_节点创建函数["网格法线计算节点"] = f_node_创建计算网格法线节点;
	g_节点加载函数["网格法线计算节点"] = f_node_载入计算网格法线节点;
	g_节点保存函数["网格法线计算节点"] = f_node_保存计算网格法线节点;

	g_节点创建函数["网格属性节点"] = f_node_创建取网格属性节点;
	g_节点加载函数["网格属性节点"] = f_node_载入取网格属性节点;
	g_节点保存函数["网格属性节点"] = f_node_保存取网格属性节点;

	g_节点创建函数["截取网格节点"] = f_node_创建截取网格节点;
	g_节点加载函数["截取网格节点"] = f_node_载入截取网格节点;
	g_节点保存函数["截取网格节点"] = f_node_保存截取网格节点;

	g_节点创建函数[DEF_网格选择节点] = f_node_创建网格选择节点;
	g_节点加载函数[DEF_网格选择节点] = f_node_载入网格选择节点;
	g_节点保存函数[DEF_网格选择节点] = f_node_保存网格选择节点;

	g_节点创建函数[DEF_填充网格顶点节点] = f_node_创建填充网格顶点节点;
	g_节点加载函数[DEF_填充网格顶点节点] = f_node_载入填充网格顶点节点;
	g_节点保存函数[DEF_填充网格顶点节点] = f_node_保存填充网格顶点节点;

	g_节点创建函数[DEF_填充网格纹理坐标节点] = f_node_创建填充网格纹理坐标节点;
	g_节点加载函数[DEF_填充网格纹理坐标节点] = f_node_载入填充网格纹理坐标节点;
	g_节点保存函数[DEF_填充网格纹理坐标节点] = f_node_保存填充网格纹理坐标节点;

	g_节点创建函数[DEF_多边形添加顶点节点] = f_node_创建多边形添加顶点节点;
	g_节点加载函数[DEF_多边形添加顶点节点] = f_node_载入多边形添加顶点节点;
	g_节点保存函数[DEF_多边形添加顶点节点] = f_node_保存多边形添加顶点节点;

	g_节点创建函数[DEF_多边形删除顶点节点] = f_node_创建多边形删除顶点节点;
	g_节点加载函数[DEF_多边形删除顶点节点] = f_node_载入多边形删除顶点节点;
	g_节点保存函数[DEF_多边形删除顶点节点] = f_node_保存多边形删除顶点节点;

	g_节点创建函数[DEF_设置多边形面UV节点] = f_node_创建设置多边形面UV节点;
	g_节点加载函数[DEF_设置多边形面UV节点] = f_node_载入设置多边形面UV节点;
	g_节点保存函数[DEF_设置多边形面UV节点] = f_node_保存设置多边形面UV节点;

	g_节点创建函数[DEF_多边形边节点] = f_node_创建构建多边形边节点;
	g_节点加载函数[DEF_多边形边节点] = f_node_载入构建多边形边节点;
	g_节点保存函数[DEF_多边形边节点] = f_node_保存构建多边形边节点;

	g_节点创建函数[DEF_多边形面节点] = f_node_创建构建多边形面节点;
	g_节点加载函数[DEF_多边形面节点] = f_node_载入构建多边形面节点;
	g_节点保存函数[DEF_多边形面节点] = f_node_保存构建多边形面节点;

	g_节点创建函数[DEF_添加多边形元素节点] = f_node_创建添加多边形元素节点;
	g_节点加载函数[DEF_添加多边形元素节点] = f_node_载入添加多边形元素节点;
	g_节点保存函数[DEF_添加多边形元素节点] = f_node_保存添加多边形元素节点;

	g_节点创建函数[DEF_添加纹理坐标节点] = f_node_创建构建多边形纹理坐标节点;
	g_节点加载函数[DEF_添加纹理坐标节点] = f_node_载入构建多边形纹理坐标节点;
	g_节点保存函数[DEF_添加纹理坐标节点] = f_node_保存构建多边形纹理坐标节点;

	g_节点创建函数[DEF_多边形桥接节点] = f_node_创建多边形桥接节点;
	g_节点加载函数[DEF_多边形桥接节点] = f_node_载入多边形桥接节点;
	g_节点保存函数[DEF_多边形桥接节点] = f_node_保存多边形桥接节点;

	g_节点创建函数[DEF_点桥接节点] = f_node_创建点桥接节点;
	g_节点加载函数[DEF_点桥接节点] = f_node_载入点桥接节点;
	g_节点保存函数[DEF_点桥接节点] = f_node_保存点桥接节点;

	g_节点创建函数[DEF_多边形边采样节点] = f_node_创建多边形边采样节点;
	g_节点加载函数[DEF_多边形边采样节点] = f_node_载入多边形边采样节点;
	g_节点保存函数[DEF_多边形边采样节点] = f_node_保存多边形边采样节点;

	g_节点创建函数[DEF_多边形边网格化节点] = f_node_创建多边形边网格化节点;
	g_节点加载函数[DEF_多边形边网格化节点] = f_node_载入多边形边网格化节点;
	g_节点保存函数[DEF_多边形边网格化节点] = f_node_保存多边形边网格化节点;

	g_节点创建函数[DEF_多边形边实体化节点] = f_node_创建多边形边实体化节点;
	g_节点加载函数[DEF_多边形边实体化节点] = f_node_载入多边形边实体化节点;
	g_节点保存函数[DEF_多边形边实体化节点] = f_node_保存多边形边实体化节点;

	g_节点创建函数[DEF_面朝向节点] = f_node_创建面朝向节点;
	g_节点加载函数[DEF_面朝向节点] = f_node_载入面朝向节点;
	g_节点保存函数[DEF_面朝向节点] = f_node_保存面朝向节点;

	g_节点创建函数[DEF_多边形索引节点] = f_node_创建多边形索引节点;
	g_节点加载函数[DEF_多边形索引节点] = f_node_载入多边形索引节点;
	g_节点保存函数[DEF_多边形索引节点] = f_node_保存多边形索引节点;

	g_节点创建函数[DEF_投影纹理坐标节点] = f_node_创建投影纹理坐标节点;
	g_节点加载函数[DEF_投影纹理坐标节点] = f_node_载入投影纹理坐标节点;
	g_节点保存函数[DEF_投影纹理坐标节点] = f_node_保存投影纹理坐标节点;

	g_节点创建函数[DEF_取多边形面属性节点] = f_node_创建取多边形属性节点;
	g_节点加载函数[DEF_取多边形面属性节点] = f_node_载入取多边形属性节点;
	g_节点保存函数[DEF_取多边形面属性节点] = f_node_保存取多边形属性节点;
	g_节点创建函数[DEF_设置多边形面属性节点] = f_node_创建设置多边形属性节点;
	g_节点加载函数[DEF_设置多边形面属性节点] = f_node_载入设置多边形属性节点;
	g_节点保存函数[DEF_设置多边形面属性节点] = f_node_保存设置多边形属性节点;

	g_节点创建函数[DEF_设置面材质槽ID节点] = f_node_创建设置面材质槽ID节点;
	g_节点加载函数[DEF_设置面材质槽ID节点] = f_node_载入设置面材质槽ID节点;
	g_节点保存函数[DEF_设置面材质槽ID节点] = f_node_保存设置面材质槽ID节点;

	g_节点创建函数[DEF_多边形复制节点] = f_node_创建多边形复制节点;
	g_节点加载函数[DEF_多边形复制节点] = f_node_载入多边形复制节点;
	g_节点保存函数[DEF_多边形复制节点] = f_node_保存多边形复制节点;

	g_节点创建函数[DEF_多边形拷贝节点] = f_node_创建拷贝多边形节点;
	g_节点加载函数[DEF_多边形拷贝节点] = f_node_载入拷贝多边形节点;
	g_节点保存函数[DEF_多边形拷贝节点] = f_node_保存拷贝多边形节点;

	g_节点创建函数[DEF_多边形变换节点] = f_node_创建多边形变换节点;
	g_节点加载函数[DEF_多边形变换节点] = f_node_载入多边形变换节点;
	g_节点保存函数[DEF_多边形变换节点] = f_node_保存多边形变换节点;

	g_节点创建函数[DEF_取多边形边节点] = f_node_创建取多边形_边节点;
	g_节点加载函数[DEF_取多边形边节点] = f_node_载入取多边形_边节点;
	g_节点保存函数[DEF_取多边形边节点] = f_node_保存取多边形_边节点;

	g_节点创建函数[DEF_取多边形面顶点节点] = f_node_创建取多边形面顶点节点;
	g_节点加载函数[DEF_取多边形面顶点节点] = f_node_载入取多边形面顶点节点;
	g_节点保存函数[DEF_取多边形面顶点节点] = f_node_保存取多边形面顶点节点;

	g_节点创建函数[DEF_取多边形面元素节点] = f_node_创建取多边形_元素节点;
	g_节点加载函数[DEF_取多边形面元素节点] = f_node_载入取多边形_元素节点;
	g_节点保存函数[DEF_取多边形面元素节点] = f_node_保存取多边形_元素节点;

	g_节点创建函数[DEF_设置多边形面顶点节点] = f_node_创建设置多边形面顶点节点;
	g_节点加载函数[DEF_设置多边形面顶点节点] = f_node_载入设置多边形面顶点节点;
	g_节点保存函数[DEF_设置多边形面顶点节点] = f_node_保存设置多边形面顶点节点;

	g_节点创建函数[DEF_多边形转网格节点] = f_node_创建多边形转网格节点;
	g_节点加载函数[DEF_多边形转网格节点] = f_node_载入多边形转网格节点;
	g_节点保存函数[DEF_多边形转网格节点] = f_node_保存多边形转网格节点;

	g_节点创建函数[DEF_取网格元素节点] = f_node_创建取网格元素节点;
	g_节点加载函数[DEF_取网格元素节点] = f_node_载入取网格元素节点;
	g_节点保存函数[DEF_取网格元素节点] = f_node_保存取网格元素节点;

	g_节点创建函数[DEF_取网格元素顶点节点] = f_node_创建取网格元素顶点节点;
	g_节点加载函数[DEF_取网格元素顶点节点] = f_node_载入取网格元素顶点节点;
	g_节点保存函数[DEF_取网格元素顶点节点] = f_node_保存取网格元素顶点节点;

	g_节点创建函数[DEF_设置网格元素顶点节点] = f_node_创建设置网格元素顶点节点;
	g_节点加载函数[DEF_设置网格元素顶点节点] = f_node_载入设置网格元素顶点节点;
	g_节点保存函数[DEF_设置网格元素顶点节点] = f_node_保存设置网格元素顶点节点;
	
	g_节点创建函数[DEF_创建网格自定义属性节点] = f_node_创建网格自定义属性节点;
	g_节点加载函数[DEF_创建网格自定义属性节点] = f_node_加载网格自定义属性节点;
	g_节点保存函数[DEF_创建网格自定义属性节点] = f_node_保存网格自定义属性节点;

	g_节点创建函数[DEF_设置网格面自定义属性节点] = f_node_创建设置网格自定义属性节点;
	g_节点加载函数[DEF_设置网格面自定义属性节点] = f_node_加载设置网格自定义属性节点;
	g_节点保存函数[DEF_设置网格面自定义属性节点] = f_node_保存设置网格自定义属性节点;




	/* ============= 物体 ============= */
	g_节点创建函数["物体节点"]			= f_node_创建物体节点;
	g_节点加载函数["物体节点"]			= f_node_加载物体节点;
	g_节点保存函数["物体节点"]			= f_node_保存物体节点;

	g_节点创建函数[DEF_引用物体节点] = f_node_创建引用物体节点;
	g_节点加载函数[DEF_引用物体节点] = f_node_加载引用物体节点;
	g_节点保存函数[DEF_引用物体节点] = f_node_保存引用物体节点;

	g_节点创建函数[DEF_取物体节点] = f_node_创建取物体节点;
	g_节点加载函数[DEF_取物体节点] = f_node_加载取物体节点;
	g_节点保存函数[DEF_取物体节点] = f_node_保存取物体节点;

	g_节点创建函数[DEF_物体虚拟体节点] = f_node_创建物体虚拟体节点;
	g_节点加载函数[DEF_物体虚拟体节点] = f_node_加载物体虚拟体节点;
	g_节点保存函数[DEF_物体虚拟体节点] = f_node_保存物体虚拟体节点;

	g_节点创建函数[DEF_取物体变换节点] = f_node_创建取物体变换节点;
	g_节点加载函数[DEF_取物体变换节点] = f_node_加载取物体变换节点;
	g_节点保存函数[DEF_取物体变换节点] = f_node_保存取物体变换节点;

	g_节点创建函数[DEF_查找子物体节点] = f_node_创建查找子物体节点;
	g_节点加载函数[DEF_查找子物体节点] = f_node_加载查找子物体节点;
	g_节点保存函数[DEF_查找子物体节点] = f_node_保存查找子物体节点;


	g_节点加载函数["物体父子关系节点"] = f_node_加载物体父子关系节点;
	g_节点保存函数["物体父子关系节点"] = f_node_保存物体父子关系节点;
	g_节点加载函数["设置物体数据节点"] = f_node_加载设置物体数据节点;
	g_节点保存函数["设置物体数据节点"] = f_node_保存设置物体数据节点;
	g_节点加载函数["取物体属性节点"] = f_node_加载取物体属性节点;
	g_节点保存函数["取物体属性节点"] = f_node_保存取物体属性节点;

	g_节点创建函数["骨头节点"] = f_node_创建骨头节点;
	g_节点加载函数["骨头节点"] = f_node_加载骨头节点;
	g_节点保存函数["骨头节点"] = f_node_保存骨头节点;

	g_节点创建函数["骨骼节点"] = f_node_创建骨骼节点;
	g_节点加载函数["骨骼节点"] = f_node_加载骨骼节点;
	g_节点保存函数["骨骼节点"] = f_node_保存骨骼节点;

	g_节点加载函数["骨骼IK节点"] = f_node_加载骨骼IK节点;
	g_节点保存函数["骨骼IK节点"] = f_node_保存骨骼IK节点;
	g_节点加载函数["物体绑定骨骼节点"] = f_node_加载物体绑定骨骼节点;
	g_节点保存函数["物体绑定骨骼节点"] = f_node_保存物体绑定骨骼节点;
	g_节点加载函数[DEF_取物体光追材质节点] = f_node_加载取物体光追材质节点;
	g_节点保存函数[DEF_取物体光追材质节点] = f_node_保存取物体光追材质节点;

	g_节点创建函数["物体拷贝节点"] = f_node_创建物体拷贝节点;
	g_节点加载函数["物体拷贝节点"] = f_node_加载物体拷贝节点;
	g_节点保存函数["物体拷贝节点"] = f_node_保存物体拷贝节点;

	g_节点加载函数["物体对称节点"] = f_node_加载物体对称节点;
	g_节点保存函数["物体对称节点"] = f_node_保存物体对称节点;
	g_节点加载函数[DEF_取物体材质节点] = f_node_加载取物体材质节点;
	g_节点保存函数[DEF_取物体材质节点] = f_node_保存取物体材质节点;

	g_节点创建函数[DEF_选择物体节点] = f_node_创建选择物体节点;
	g_节点加载函数[DEF_选择物体节点] = f_node_加载选择物体节点;
	g_节点保存函数[DEF_选择物体节点] = f_node_保存选择物体节点;

	g_节点创建函数["设置物体矩阵节点"] = f_node_创建设置物体矩阵节点;
	g_节点加载函数["设置物体矩阵节点"] = f_node_加载设置物体矩阵节点;
	g_节点保存函数["设置物体矩阵节点"]	= f_node_保存设置物体矩阵节点;

	g_节点创建函数[DEF_取物体矩阵节点] = f_node_创建取物体矩阵节点;
	g_节点加载函数[DEF_取物体矩阵节点] = f_node_加载取物体矩阵节点;
	g_节点保存函数[DEF_取物体矩阵节点]	= f_node_保存取物体矩阵节点;

	g_节点创建函数[DEF_设置物体变换节点] = f_node_创建设置物体变换节点;
	g_节点加载函数[DEF_设置物体变换节点] = f_node_加载设置物体变换节点;
	g_节点保存函数[DEF_设置物体变换节点] = f_node_保存设置物体变换节点;

	g_节点创建函数[DEF_外部加载物体节点] = f_node_创建外部加载物体节点;
	g_节点加载函数[DEF_外部加载物体节点] = f_node_加载外部加载物体节点;
	g_节点保存函数[DEF_外部加载物体节点] = f_node_保存外部加载物体节点;

	g_节点创建函数[DEF_加载模型节点] = f_node_创建加载模型节点;
	g_节点加载函数[DEF_加载模型节点] = f_node_加载加载模型节点;
	g_节点保存函数[DEF_加载模型节点] = f_node_保存加载模型节点;

	g_节点加载函数["蒙皮节点"] = f_node_加载蒙皮节点;
	g_节点保存函数["蒙皮节点"] = f_node_保存蒙皮节点;

	g_节点创建函数[DEF_摄像机节点] = f_node_创建摄像机节点;
	g_节点加载函数[DEF_摄像机节点] = f_node_加载摄像机节点;
	g_节点保存函数[DEF_摄像机节点] = f_node_保存摄像机节点;

	g_节点创建函数[DEF_点光源节点] = f_node_创建点光源节点;
	g_节点加载函数[DEF_点光源节点] = f_node_加载点光源节点;
	g_节点保存函数[DEF_点光源节点] = f_node_保存点光源节点;

	g_节点创建函数[DEF_区域光节点] = f_node_创建面光源节点;
	g_节点加载函数[DEF_区域光节点] = f_node_加载面光源节点;
	g_节点保存函数[DEF_区域光节点] = f_node_保存面光源节点;

	g_节点创建函数[DEF_平行光节点] = f_node_创建平行光节点;
	g_节点加载函数[DEF_平行光节点] = f_node_加载平行光节点;
	g_节点保存函数[DEF_平行光节点] = f_node_保存平行光节点;

	g_节点创建函数[DEF_聚光灯节点] = f_node_创建聚光灯节点;
	g_节点加载函数[DEF_聚光灯节点] = f_node_加载聚光灯节点;
	g_节点保存函数[DEF_聚光灯节点] = f_node_保存聚光灯节点;

	g_节点创建函数[DEF_目标摄像机节点] = f_node_创建目标摄像机节点;
	g_节点加载函数[DEF_目标摄像机节点] = f_node_加载目标摄像机节点;
	g_节点保存函数[DEF_目标摄像机节点] = f_node_保存目标摄像机节点;

	g_节点创建函数[DEF_设置摄像机属性节点] = f_node_创建设置摄像机属性节点;
	g_节点加载函数[DEF_设置摄像机属性节点] = f_node_加载设置摄像机属性节点;
	g_节点保存函数[DEF_设置摄像机属性节点] = f_node_保存设置摄像机属性节点;



	/* ============= 材质 ============= */
	g_节点创建函数[DEF_材质槽节点] = f_node_创建材质槽节点;
	g_节点加载函数[DEF_材质槽节点] = f_node_加载材质槽节点;
	g_节点保存函数[DEF_材质槽节点] = f_node_保存材质槽节点;
	g_节点创建函数[DEF_材质编辑节点] = f_node_创建材质节点;
	g_节点加载函数[DEF_材质编辑节点] = f_node_加载材质节点;
	g_节点保存函数[DEF_材质编辑节点] = f_node_保存材质节点;

	g_节点创建函数[DEF_当前材质节点] = f_node_创建当前材质节点;
	g_节点加载函数[DEF_当前材质节点] = f_node_加载当前材质节点;
	g_节点保存函数[DEF_当前材质节点] = f_node_保存当前材质节点;

	g_节点创建函数[DEF_着色器节点] = f_node_创建着色器节点;
	g_节点加载函数[DEF_着色器节点] = f_node_加载着色器节点;
	g_节点保存函数[DEF_着色器节点] = f_node_保存着色器节点;
	g_节点加载函数[DEF_自发光材质节点] = f_node_加载自发光材质节点;
	g_节点保存函数[DEF_自发光材质节点] = f_node_保存自发光材质节点;
	g_节点创建函数[DEF_纹理节点] = f_node_创建纹理节点;
	g_节点加载函数[DEF_纹理节点] = f_node_加载纹理节点;
	g_节点保存函数[DEF_纹理节点] = f_node_保存纹理节点;

	g_节点创建函数[DEF_外部纹理节点] = f_node_创建外部纹理节点;
	g_节点加载函数[DEF_外部纹理节点] = f_node_加载外部纹理节点;
	g_节点保存函数[DEF_外部纹理节点] = f_node_保存外部纹理节点;

	g_节点创建函数[DEF_外部纹理集节点] = f_node_创建外部纹理集节点;
	g_节点加载函数[DEF_外部纹理集节点] = f_node_加载外部纹理集节点;
	g_节点保存函数[DEF_外部纹理集节点] = f_node_保存外部纹理集节点;

	g_节点创建函数[DEF_渐变纹理节点] = f_node_创建渐变纹理节点;
	g_节点加载函数[DEF_渐变纹理节点] = f_node_加载渐变纹理节点;
	g_节点保存函数[DEF_渐变纹理节点] = f_node_保存渐变纹理节点;
	g_节点创建函数[DEF_棋盘格纹理节点] = f_node_创建棋盘格纹理节点;
	g_节点加载函数[DEF_棋盘格纹理节点] = f_node_加载棋盘格纹理节点;
	g_节点保存函数[DEF_棋盘格纹理节点] = f_node_保存棋盘格纹理节点;

	g_节点创建函数[DEF_2D纹理采样节点] = f_node_创建纹理采样节点;
	g_节点加载函数[DEF_2D纹理采样节点] = f_node_加载纹理采样节点;
	g_节点保存函数[DEF_2D纹理采样节点] = f_node_保存纹理采样节点;

	g_节点创建函数[DEF_2D纹理数组采样节点] = f_node_创建2D纹理数组采样节点;
	g_节点加载函数[DEF_2D纹理数组采样节点] = f_node_加载2D纹理数组采样节点;
	g_节点保存函数[DEF_2D纹理数组采样节点] = f_node_保存2D纹理数组采样节点;

	g_节点创建函数[DEF_字符纹理节点] = f_node_创建字符纹理节点;
	g_节点加载函数[DEF_字符纹理节点] = f_node_加载字符纹理节点;
	g_节点保存函数[DEF_字符纹理节点] = f_node_保存字符纹理节点;

	g_节点创建函数[DEF_字符纹理坐标节点] = f_node_创建字符纹理坐标节点;
	g_节点加载函数[DEF_字符纹理坐标节点] = f_node_加载字符纹理坐标节点;
	g_节点保存函数[DEF_字符纹理坐标节点] = f_node_保存字符纹理坐标节点;

	g_节点创建函数[DEF_字符纹理排列节点] = f_node_创建字符纹理排列节点;
	g_节点加载函数[DEF_字符纹理排列节点] = f_node_加载字符纹理排列节点;
	g_节点保存函数[DEF_字符纹理排列节点] = f_node_保存字符纹理排列节点;

	g_节点创建函数[DEF_噪波纹理节点] = f_node_创建噪波纹理节点;
	g_节点加载函数[DEF_噪波纹理节点] = f_node_加载噪波纹理节点;
	g_节点保存函数[DEF_噪波纹理节点] = f_node_保存噪波纹理节点;
	g_节点创建函数[DEF_PBR着色器节点] = f_node_创建设置PBR材质属性节点;
	g_节点加载函数[DEF_PBR着色器节点] = f_node_加载设置PBR材质属性节点;
	g_节点保存函数[DEF_PBR着色器节点] = f_node_保存设置PBR材质属性节点;
	g_节点创建函数[DEF_设置网格材质节点] = f_node_创建设置物体材质节点;
	g_节点加载函数[DEF_设置网格材质节点] = f_node_加载设置物体材质节点;
	g_节点保存函数[DEF_设置网格材质节点] = f_node_保存设置物体材质节点;

	g_节点创建函数[DEF_基于物理计算着色节点] = f_node_创建基于物理计算着色节点;
	g_节点加载函数[DEF_基于物理计算着色节点] = f_node_加载基于物理计算着色节点;
	g_节点保存函数[DEF_基于物理计算着色节点] = f_node_保存基于物理计算着色节点;

	g_节点创建函数[DEF_几何数据节点] = f_node_创建几何数据节点;
	g_节点加载函数[DEF_几何数据节点] = f_node_加载几何数据节点;
	g_节点保存函数[DEF_几何数据节点] = f_node_保存几何数据节点;

	g_节点创建函数[DEF_光线数据节点] = f_node_创建光线数据节点;
	g_节点加载函数[DEF_光线数据节点] = f_node_加载光线数据节点;
	g_节点保存函数[DEF_光线数据节点] = f_node_保存光线数据节点;

	g_节点创建函数[DEF_几何UV数据节点] = f_node_创建几何UV数据节点;
	g_节点加载函数[DEF_几何UV数据节点] = f_node_加载几何UV数据节点;
	g_节点保存函数[DEF_几何UV数据节点] = f_node_保存几何UV数据节点;

	g_节点创建函数[DEF_材质器网格自定义属性数据节点] = f_node_创建着色器网格自定义属性数据节点;
	g_节点加载函数[DEF_材质器网格自定义属性数据节点] = f_node_加载着色器网格自定义属性数据节点;
	g_节点保存函数[DEF_材质器网格自定义属性数据节点] = f_node_保存着色器网格自定义属性数据节点;





	/* ============= 场景 ============= */
	g_节点加载函数["射线拾取节点"] = f_node_载入射线拾取节点;
	g_节点保存函数["射线拾取节点"] = f_node_保存射线拾取节点;
	g_节点加载函数["范围拾取节点"] = f_node_载入范围拾取节点;
	g_节点保存函数["范围拾取节点"] = f_node_保存范围拾取节点;
	g_节点创建函数["帧时间节点"] = f_node_创建帧时间节点;
	g_节点加载函数["帧时间节点"] = f_node_载入帧时间节点;
	g_节点保存函数["帧时间节点"] = f_node_保存帧时间节点;
	g_节点加载函数["OpenVDB网格节点"] = f_node_载入OpenVDB网格节点;
	g_节点保存函数["OpenVDB网格节点"] = f_node_保存OpenVDB网格节点;
	g_节点加载函数["视口物体操作手柄节点"] = f_node_载入视口物体操作手柄节点;
	g_节点保存函数["视口物体操作手柄节点"] = f_node_保存视口物体操作手柄节点;





	/* ============= 物理 ============= */
	g_节点加载函数["粒子节点"]			= f_node_加载粒子节点;
	g_节点保存函数["粒子节点"]			= f_node_保存粒子节点;
	g_节点加载函数["面粒子发射节点"]	= f_node_加载手动面粒子发射节点;
	g_节点加载函数["物理碰撞节点"]		= f_node_加载物理碰撞节点;
	g_节点加载函数["单方向物理力节点"]	= f_node_加载单方向物理力节点;

	g_节点加载函数[DEF_物理几何体节点] = f_node_加载物理几何体节点;
	g_节点保存函数[DEF_物理几何体节点] = f_node_保存物理几何体节点;
	g_节点加载函数[DEF_物理体节点]		= f_node_加载物理体节点;
	g_节点保存函数[DEF_物理体节点]		= f_node_保存物理体节点;
	g_节点加载函数["物理体添加节点"]		= f_node_加载物理体添加节点;
	g_节点保存函数["物理体添加节点"]		= f_node_保存物理体添加节点;
	g_节点加载函数["发射节点"]			= f_node_加载发射节点;
	g_节点保存函数["发射节点"]			= f_node_保存发射节点;

	g_节点加载函数["物理变换回写节点"]	= f_node_加载物理变换回写节点;

	g_节点加载函数["FLIP解算器节点"]	= f_node_加载FLIP解算器节点;
	g_节点保存函数["FLIP解算器节点"]	= f_node_保存FLIP解算器节点;

	g_节点加载函数[DEF_物理引擎节点] = f_node_加载物理引擎节点;
	g_节点保存函数[DEF_物理引擎节点] = f_node_保存物理引擎节点;
	g_节点加载函数["PBF解算器节点"] = f_node_加载PBF解算器节点;
	g_节点保存函数["PBF解算器节点"] = f_node_保存PBF解算器节点;
	g_节点加载函数[DEF_应用力节点] = f_node_加载应用力节点;
	g_节点保存函数[DEF_应用力节点] = f_node_保存应用力节点;
	g_节点加载函数[DEF_更新肌腱节点] = f_node_加载更新肌腱节点;
	g_节点保存函数[DEF_更新肌腱节点] = f_node_保存更新肌腱节点;

	g_节点加载函数["解算器更新节点"] = f_node_加载解算器更新节点;
	g_节点保存函数["解算器更新节点"] = f_node_保存解算器更新节点;

	g_节点加载函数["FleX参数节点"]	 = f_node_加载FleX参数节点;
	g_节点保存函数["FleX参数节点"]	= f_node_保存FleX参数节点;

	g_节点加载函数["解算器添加物体节点"] = f_node_加载解算器添加物体节点;
	g_节点加载函数["解算器添加物体节点"]	= f_node_加载解算器更新节点;

	g_节点加载函数[DEF_物理体绑定物体节点] = f_node_加载物理体绑定物体节点;
	g_节点保存函数[DEF_物理体绑定物体节点] = f_node_保存物理体绑定物体节点;
	g_节点加载函数[DEF_取物理体节点] = f_node_加载取物理体节点;
	g_节点保存函数[DEF_取物理体节点] = f_node_保存取物理体节点;
	g_节点加载函数[DEF_物理引擎内部几何节点] = f_node_加载物理引擎内部几何节点;
	g_节点保存函数[DEF_物理引擎内部几何节点] = f_node_保存物理引擎内部几何节点;



	/* ============= 逻辑 ============= */
	g_节点创建函数[DEF_循环头节点] = f_node_创建循环迭代节点;
	g_节点加载函数[DEF_循环头节点] = f_node_加载循环迭代节点;
	g_节点保存函数[DEF_循环头节点] = f_node_保存循环迭代节点;

	g_节点创建函数[DEF_循环节点] = f_node_创建循环节点;
	g_节点加载函数[DEF_循环节点] = f_node_加载循环节点;
	g_节点保存函数[DEF_循环节点] = f_node_保存循环节点;

	g_节点创建函数[DEF_迭代节点] = f_node_创建迭代节点;
	g_节点加载函数[DEF_迭代节点] = f_node_加载迭代节点;
	g_节点保存函数[DEF_迭代节点] = f_node_保存迭代节点;

	g_节点创建函数[DEF_循环尾节点] = f_node_创建循环尾节点;
	g_节点加载函数[DEF_循环尾节点] = f_node_加载循环尾节点;
	g_节点保存函数[DEF_循环尾节点] = f_node_保存循环尾节点;

	g_节点创建函数[DEF_跳过节点] = f_node_创建跳过节点;
	g_节点加载函数[DEF_跳过节点] = f_node_加载跳过节点;
	g_节点保存函数[DEF_跳过节点] = f_node_保存跳过节点;

	g_节点创建函数[DEF_输入组节点] = f_node_创建输入组节点;
	g_节点加载函数[DEF_输入组节点] = f_node_加载输入组节点;
	g_节点保存函数[DEF_输入组节点] = f_node_保存输入组节点;

	g_节点创建函数[DEF_输出组节点] = f_node_创建输出组节点;
	g_节点加载函数[DEF_输出组节点] = f_node_加载输出组节点;
	g_节点保存函数[DEF_输出组节点] = f_node_保存输出组节点;

	g_节点加载函数[DEF_Python节点] = f_node_加载Python节点;
	g_节点保存函数[DEF_Python节点] = f_node_保存Python节点;

	g_节点创建函数[DEF_分支判断节点] = f_node_创建分支判断节点;
	g_节点加载函数[DEF_分支判断节点] = f_node_加载分支判断节点;
	g_节点保存函数[DEF_分支判断节点] = f_node_保存分支判断节点;

	g_节点创建函数[DEF_函数节点] = f_node_创建函数节点;
	g_节点加载函数[DEF_函数节点] = f_node_加载函数节点;
	g_节点保存函数[DEF_函数节点] = f_node_保存函数节点;

	g_节点创建函数[DEF_包节点] = f_node_创建包节点;
	g_节点加载函数[DEF_包节点] = f_node_加载包节点;
	g_节点保存函数[DEF_包节点] = f_node_保存包节点;

	g_节点创建函数[DEF_插座转接节点] = f_node_创建插座转接节点;
	g_节点加载函数[DEF_插座转接节点] = f_node_加载插座转接节点;
	g_节点保存函数[DEF_插座转接节点] = f_node_保存插座转接节点;

	g_节点创建函数[DEF_面板框节点] = f_node_创建面板域节点;
	g_节点加载函数[DEF_面板框节点] = f_node_加载面板域节点;
	g_节点保存函数[DEF_面板框节点] = f_node_保存面板域节点;



	/* ============= 调试 ============= */
	g_节点创建函数[DEF_调试输出节点] = f_node_创建信息输出节点;
	g_节点加载函数[DEF_调试输出节点] = f_node_载入信息输出节点;
	g_节点保存函数[DEF_调试输出节点] = f_node_保存信息输出节点;
	g_节点加载函数["几何预览节点"] = f_node_载入几何预览节点;
	g_节点保存函数["几何预览节点"] = f_node_保存几何预览节点;

	g_节点创建函数[DEF_控制台输出节点] = f_node_创建控制台输出节点;
	g_节点加载函数[DEF_控制台输出节点] = f_node_加载控制台输出节点;
	g_节点保存函数[DEF_控制台输出节点] = f_node_保存控制台输出节点;



	/* ============= 渲染器 ============= */
	g_节点创建函数[DEF_渲染器配置节点] = f_node_创建渲染器配置节点;
	g_节点加载函数[DEF_渲染器配置节点] = f_node_加载渲染器配置节点;
	g_节点保存函数[DEF_渲染器配置节点] = f_node_保存渲染器配置节点;

	g_节点创建函数[DEF_渲染输出节点] = f_node_创建渲染输出节点;
	g_节点加载函数[DEF_渲染输出节点] = f_node_加载渲染输出节点;
	g_节点保存函数[DEF_渲染输出节点] = f_node_保存渲染输出节点;





	//===================== 保存函数 =========================
	g_节点保存函数["动画轨道节点"] = f_node_save动画轨道节点;
	g_节点保存函数["手动执行节点"] = f_node_保存手动执行节点;
	g_节点保存函数["合并数据节点"] = f_node_保存合并数据节点;
	

	






	f_NodeCtx_全局初始化();
	f_NodeCtx_物理模拟初始化();
	//f_init_JTI();
	f_node_所有变量类节点JIT初始化();
	f_node_所有网格类节点JIT初始化();
	f_node_所有计算类节点JIT初始化();
	f_node_所有材质纹理节点JIT初始化();
	f_node_物体类节点JIT函数初始化();
	f_node_所有调试类节点JIT初始化();

	
}


void f_node_环境销毁() {
	f_node_帧更新(false);
	f_NodeCtx_物理模拟销毁();


	Py_Finalize();
	WSACleanup();

	f_node后端_销毁所有节点树();

	f_material_releasePBR(g渲染器默认材质);

	f_NodeCtx_全局释放();
	

	if (g渲染器默认纹理) {
		f_tex_销毁纹理(g渲染器默认纹理);
		g渲染器默认纹理 = nullptr;
	}
	if (g渲染器默认字符纹理) {
		f_tex_销毁纹理(g渲染器默认字符纹理);
		g渲染器默认字符纹理 = nullptr;
	}
}

void f_node_set默认操作数据(S_Scene* scene, S_设备环境& 绘图环境) {
	f_NodeCtx_set默认场景(scene);

	S_绘图框架::g_资源加载管道 = f_bd_创建子集绘图命令(f_df_get绘图环境(绘图环境), 32);


	/* ===================== 网格 ===================== */
	f_NodeCtx_初始化物体材质(绘图环境);

	g渲染器默认纹理 = f_scene_创建纹理(scene, 绘图环境, L"渲染器默认纹理", S_光追后端::E_纹理分组类型::e_2D纹理);
	g渲染器默认材质 = f_material_createPBR();

	f_tex_从文件填充纹理(g渲染器默认纹理, (S_引擎配置::g_程序路径) + "0.png", f_NodeCtx_get默认场景()->m_光追后端->m_渲染命令缓存);
	f_scene_重载渲染器绑定纹理(scene, g渲染器默认纹理);

	
	g渲染器默认字符纹理 = f_tex_创建图像纹理(绘图环境, {16,16,1}, E_纹理格式::e_tf_R8U_U, E_纹理维度类型::e_2D_Array);
	std::vector<uint8> 默认字符纹理填充(16 * 16, 255);
	f_tex_填充纹理数据(g渲染器默认字符纹理, 默认字符纹理填充.data(), sizeof(uint8), { 16,16,1 });
	g渲染器默认字符纹理 = f_scene_创建纹理(scene, 绘图环境, L"文字默认空纹理", S_光追后端::E_纹理分组类型::e_字符纹理, g渲染器默认字符纹理);
	

}




C_节点树* f_node_get节点树(uint16 id) {
	if(id < S_节点数据::g_根节点树.size()) return S_节点数据::g_根节点树[id];
	return nullptr;
}

uint32 f_NT_get数量() {
	return S_节点数据::g_根节点树.size();
}



void f_node_节点树添加节点(C_节点树* tree, C_节点基类* node) {
	g添加删除锁.lock();

	tree->f_添加节点(node);
	tree->m_节点结构改变 = true;

	node->f_get子集树();

	g添加删除锁.unlock();
}

void f_node_节点树删除节点(C_节点树* tree, C_节点基类* node) {
	g添加删除锁.lock();

	f_node_销毁程序集(node->f_get所在节点树());
	f_node_销毁程序集(tree);

	tree->f_删除节点(node);

	g添加删除锁.unlock();
}

void f_node_停止运行节点树() {
	g是否运行节点树 = false;
	g节点运行线程.joinable();
	g暂停绘制部件.clear();
}





static std::thread g_节点执行线程;
static std::atomic_bool g_线程是否在执行 = false;
static std::mutex g_线程是否在执行锁;

static void f_节点更新线程() {
	//g_线程是否在执行锁.lock();
	
	for (auto& e : S_节点数据::g_根节点树) {
		e->f_准备Update();

		bool 是否中断 = false;
		uint32 num = e->m_层更新节点.size();
		for (uint32 i = 0; i < num; ++i) {
			是否中断 = e->f_Update(i);

			if (是否中断) {
				e->m_中断层 = i;
				break;
			}
		}
	}

	auto* scene = f_NodeCtx_get默认场景();
	//scene->f_Update();
	scene->m_Physics.f_模拟();
	//m_Physics.f_应用变换到物体();
	g_线程是否在执行 = false;
	//g_线程是否在执行锁.unlock();
}



void f_node_准备帧更新节点() {
	for (auto& e : S_节点数据::g_根节点树) {
		uint32 num = e->m_层更新节点.size();
		if (!num) continue;

		if (f_node_帧是否更新()) {
			for (auto& n : e->m_层更新节点[0]) {
				//if (n->f_get更新方式() == E_节点更新方式::e_节点更新_逐帧) {
				//	n->f_set是否要更新(true);
				//}
				if (n->f_get更新方式() == E_节点更新方式::e_节点更新_实时) {
					n->f_set是否要更新(true);
				}
			}
		}
	}
}


bool f_node_Step节点树() {
	//f_NodeCtx_get默认场景()->f_Update(nullptr);

	//return false;
	bool 是否中断 = false;
	for (auto& e : S_节点数据::g_根节点树) {
		e->f_准备Update();
		e->m_开启帧更新 = S_节点数据::g_开启节点帧更新;
		
		uint32 num = e->m_层更新节点.size();
		for (uint32 i = 0; i < num; ++i) {
			if (e->f_Update(i)) {
				e->m_中断层 = i;
				是否中断 = true;
				break;
			}
		}
	}

	是否中断 = false;
	for (auto& e : S_节点数据::g_渲染根节点树) {
		e->f_准备Update();
		e->m_开启帧更新 = S_节点数据::g_开启节点帧更新;

		uint32 num = e->m_层更新节点.size();
		for (uint32 i = 0; i < num; ++i) {
			if (e->f_Update(i)) {
				e->m_中断层 = i;
				是否中断 = true;
				break;
			}
		}
	}

	f_node_销毁插座();

	S_节点数据::g_开启节点帧更新 = false;
	return !是否中断;
}

bool f_node_Step渲染节点树(int32 帧) {
	//return false;
	S_节点数据::g_渲染帧编号 = 帧;

	bool 是否中断 = false;
	for (auto& e : S_节点数据::g_渲染根节点树) {
		e->f_准备Update();
		e->m_开启帧更新 = true;

		uint32 num = e->m_层更新节点.size();
		for (uint32 i = 0; i < num; ++i) {
			if (e->f_Update(i)) {
				e->m_中断层 = i;
				是否中断 = true;
				break;
			}
		}
	}
	return !是否中断;
}




std::vector<C_节点基类*> f_node_深拷贝(C_节点基类** node, uint32 num, bool 节点树拷贝) {
	std::vector<S_节点链接线记录*>		m_节点链接线记录;
	std::map<std::wstring, C_节点基类*>	m_新节点;

	std::vector<C_节点基类*> 返回的新节点;

	for(uint32 i=0; i<num; ++i){
		uint32 socketNum = node[i]->f_get输入插座Num();

		for (uint32 j = 0; j < socketNum; ++j) {
			S_节点链接线记录* 链接线记录 = new S_节点链接线记录;

			链接线记录->m_当前节点名称 = node[i]->f_getWName();
			链接线记录->m_当前节点输入插座ID = j;

			auto* p_socket = node[i]->f_get输入插座(j);
			auto lls = p_socket->f_getLinkLines();
			for (auto& link : lls) {
				S_节点链接线记录::S_节点链接线链接到输出插座记录 链接到输出插座记录;

				auto 链接线的输出插座链接到的节点 = link->m_插座out->f_getNode();
				int16 loc = 链接线的输出插座链接到的节点->f_get输出插座Loc(link->m_插座out);

				链接到输出插座记录.m_链接到的输出插座所在节点 = 链接线的输出插座链接到的节点->f_getWName();
				链接到输出插座记录.m_链接到的输出插座ID = loc;

				链接线记录->m_链接到输出插座.push_back(链接到输出插座记录);
			}

			m_节点链接线记录.push_back(链接线记录);
		}

		

		std::vector<C_节点基类*> 要拷贝的子集节点;
		C_节点树* t = nullptr;
		bool 拷贝节点树 = false;
		switch (node[i]->m_Type) {
		case E_节点类型::e_节点Type_几何: t = f_node_Create几何节点树(false); 拷贝节点树 = true; break;
		case E_节点类型::e_节点Type_包: t = f_node_Create包节点树(false); 拷贝节点树 = true; break;
		case E_节点类型::e_节点Type_循环迭代: t = f_node_Create循环节点树(false); 拷贝节点树 = true; break;

		case E_节点类型::e_节点Type_函数: {
			if (节点树拷贝) {
				t = f_node_Create函数节点树(false, L"fun_");
				拷贝节点树 = true;
			}
			else {
				t = node[i]->f_get子集树();
			}
			break;
		}
		default:
			t = node[i]->f_get子集树();
			break;
		}

		if (拷贝节点树) {
			auto* 子集节点树 = node[i]->f_get子集树();
			要拷贝的子集节点.assign(子集节点树->m_Nodes.begin(), 子集节点树->m_Nodes.end());
		}
		//f_node_销毁程序集(self->m_NodeData->f_get所在节点树());
		//f_node_销毁程序集(t);


		//========================================= 节点拷贝 ===============================================
		assert(g_节点创建函数.find(node[i]->m_TypeName) != g_节点创建函数.end());
		auto* newNode = g_节点创建函数[node[i]->m_TypeName](node[i]->m_Ctx, t);

		f_NT_设置节点名称(newNode, node[i]->f_getWName());
		newNode->m_坐标 = node[i]->m_坐标;
		newNode->m_ICO = node[i]->m_ICO;
		newNode->m_插座可编辑 = node[i]->m_插座可编辑;
		newNode->f_Copy(node[i]);

		//========================================= 插座拷贝 ===============================================
		for (uint32 j = 0; j < socketNum; ++j) {
			auto* p_socket = node[i]->f_get输入插座(j);
			if (j >= newNode->f_get输入插座Num()) {
				auto socket = f_su_创建节点后端插座(p_socket->m_identifier, p_socket->m_Type);
				socket->f_Copy(p_socket);
				newNode->f_add插座(socket, E_插座方向::e_插座Type_输入);
			}
			else {
				auto socket = f_su_切换后端插座类型(newNode, E_插座方向::e_插座Type_输入, j, p_socket->m_Type);
				//if(socket->on_UI更新) socket->on_UI更新(socket);
				socket->f_Copy(p_socket);
				socket->m_identifier = p_socket->m_identifier;
			}
		}
		socketNum = node[i]->f_get输出插座Num();
		for (uint32 j = 0; j < socketNum; ++j) {
			auto* p_socket = node[i]->f_get输出插座(j);
			if (j >= newNode->f_get输出插座Num()) {
				newNode->f_add插座(f_su_创建节点后端插座(p_socket->m_identifier, p_socket->m_Type), E_插座方向::e_插座Type_输出);
			}
			else {
				auto socket = f_su_切换后端插座类型(newNode, E_插座方向::e_插座Type_输出, j, p_socket->m_Type);
				//if (socket->on_UI更新) socket->on_UI更新(socket);
				socket->m_identifier = p_socket->m_identifier;
			}
		}

		m_新节点[node[i]->f_getWName()] = newNode;
		返回的新节点.push_back(newNode);


		if (拷贝节点树) {
			if (要拷贝的子集节点.size()) {
				auto 新子集节点 = f_node_深拷贝(要拷贝的子集节点.data(), 要拷贝的子集节点.size(), false);
				for (auto& e : 新子集节点) {
					t->f_添加节点(e);
				}
			}
		}


		

	}

	for (auto& e : m_节点链接线记录) {
		if (m_新节点.find(e->m_当前节点名称) != m_新节点.end()) {
			auto* node = m_新节点[e->m_当前节点名称];
			auto* inSocket = node->f_get输入插座(e->m_当前节点输入插座ID);

			uint32 链接线数量 = e->m_链接到输出插座.size();
			for (auto& 链接信息 : e->m_链接到输出插座) {
				if (m_新节点.find(链接信息.m_链接到的输出插座所在节点) != m_新节点.end()) {
					S_NodeLink* link = new S_NodeLink;
					auto* 链接到的节点面板 = m_新节点[链接信息.m_链接到的输出插座所在节点];
					link->f_Link(inSocket, 链接到的节点面板->f_get输出插座(链接信息.m_链接到的输出插座ID));
				}
			}
		}
	}



	for (uint32 i = 0; i < num; ++i) {
		//if(E_节点类型::e_节点Type_框 == node[i]->m_Type && node[i]->)
		switch (node[i]->m_Type) {
			case E_节点类型::e_节点Type_框: {
				f_NT_构建框节点依赖结构(m_新节点[node[i]->f_getWName()], node[i]->m_框包含节点, m_新节点);
				break;
			}
		}
	}


	return 返回的新节点;
}


C_节点树* f_NT_拷贝(C_节点树* 节点树) {
	C_节点树* newTree = nullptr;
	switch (节点树->m_树类型) {
	case E_节点树类型::e_type_物体节点树: newTree = f_node_Create节点树(false); break;
	case E_节点树类型::e_type_包节点树: newTree = f_node_Create包节点树(false); break;
	case E_节点树类型::e_type_几何节点树: newTree = f_node_Create几何节点树(false); break;
	case E_节点树类型::e_type_材质节点树: newTree = f_node_Create材质节点树(false); break;
	case E_节点树类型::e_type_循环节点树: newTree = f_node_Create循环节点树(false); break;
	case E_节点树类型::e_type_着色节点树: newTree = f_node_Create着色节点树(false); break;
	case E_节点树类型::e_type_函数节点树: newTree = f_node_Create函数节点树(false); break;
	}

	std::vector<C_节点基类*> nodes;
	nodes.assign(节点树->m_Nodes.begin(), 节点树->m_Nodes.end());
	//for (auto& e : 节点树->m_Nodes) { }
	auto 子集节点 = f_node_深拷贝(nodes.data(), nodes.size(), false);

	for (auto& e : 子集节点) newTree->f_添加节点(e);

	return newTree;
}


void f_node_添加暂停绘制部件(C_Widget* w) {
	g暂停绘制部件.push_back(w);
}



static void f_关联循环节点(C_节点基类* n, std::map<std::wstring, C_节点基类*>& nodes) {
	switch (n->m_Type) {
	case E_节点类型::e_节点Type_循环: {
		auto name = f_prop_Str(((C_循环节点*)n)->m_循环尾节点名称);
		//C_循环尾节点* 循环尾节点 = (C_循环尾节点*)nodes[name];
		//assert(循环尾节点);
		//((C_循环节点*)n)->m_循环尾节点 = (C_循环尾节点*)循环尾节点;
		//f_配对循环节点头和尾(((C_循环节点*)n), 循环尾节点);
		break;
	}
	default:
		break;
	}
}


void f_node后端_销毁所有节点树() {
	for (auto& e : S_节点数据::g_物体节点树) {
		f_NT_销毁节点((C_节点树*)e.m_Ptr);
	}
	for (auto& e : S_节点数据::g_包节点树) {
		f_NT_销毁节点((C_节点树*)e.m_Ptr);
	}
	for (auto& e : S_节点数据::g_几何节点树) {
		f_NT_销毁节点((C_节点树*)e.m_Ptr);
	}
	for (auto& e : S_节点数据::g_渲染节点树) {
		f_NT_销毁节点((C_节点树*)e.m_Ptr);
	}
	for (auto& e : S_节点数据::g_函数节点树) {
		f_NT_销毁节点((C_节点树*)e.m_Ptr);
	}
	for (auto& e : S_节点数据::g_材质节点树) {
		f_NT_销毁节点((C_节点树*)e.m_Ptr);
	}
	//for (auto& e : S_节点数据::g_着色节点树) {
	//	f_NT_销毁节点((C_节点树*)e.m_Ptr);
	//}

	for (auto& e : S_节点数据::g_物体节点树) {
		f_NT_Release((C_节点树*)e.m_Ptr);
	}
	for (auto& e : S_节点数据::g_包节点树) {
		f_NT_Release((C_节点树*)e.m_Ptr);
	}
	for (auto& e : S_节点数据::g_几何节点树) {
		f_NT_Release((C_节点树*)e.m_Ptr);
	}
	for (auto& e : S_节点数据::g_渲染节点树) {
		f_NT_Release((C_节点树*)e.m_Ptr);
	}
	for (auto& e : S_节点数据::g_函数节点树) {
		f_NT_Release((C_节点树*)e.m_Ptr);
	}
	for (auto& e : S_节点数据::g_材质节点树) {
		f_NT_Release((C_节点树*)e.m_Ptr);
	}
	for (auto& e : S_节点数据::g_着色节点树) {
		f_NT_Release((C_节点树*)e.m_Ptr);
	}

	S_节点数据::g_根节点树.clear();
	S_节点数据::g_渲染根节点树.clear();

	S_节点数据::g_物体节点树.clear();
	S_节点数据::g_包节点树.clear();
	S_节点数据::g_几何节点树.clear();
	S_节点数据::g_渲染节点树.clear();
	S_节点数据::g_材质节点树.clear();
	S_节点数据::g_着色节点树.clear();
	S_节点数据::g_函数节点树.clear();


	S_节点数据::g_节点树名称分配器.f_Clear();
	S_节点数据::g_着色器ID分配器.f_Clear();

	C_节点树::G节点名称分配.f_Clear();
}

void f_node后端_所有节点树设置为准备保存状态() {
	for (auto& e : S_节点数据::g_包节点树) {
		((C_节点树*)e.m_Ptr)->m_未保存或加载 = true;
	}
	for (auto& e : S_节点数据::g_函数节点树) {
		((C_节点树*)e.m_Ptr)->m_未保存或加载 = true;
	}
	for (auto& e : S_节点数据::g_几何节点树) {
		((C_节点树*)e.m_Ptr)->m_未保存或加载 = true;
	}
	for (auto& e : S_节点数据::g_材质节点树) {
		((C_节点树*)e.m_Ptr)->m_未保存或加载 = true;
	}
	for (auto& e : S_节点数据::g_着色节点树) {
		((C_节点树*)e.m_Ptr)->m_未保存或加载 = true;
	}
	for (auto& e : S_节点数据::g_渲染节点树) {
		((C_节点树*)e.m_Ptr)->m_未保存或加载 = true;
	}
	for (auto& e : S_节点数据::g_物体节点树) {
		((C_节点树*)e.m_Ptr)->m_未保存或加载 = true;
	}
}

void f_node后端_设置节点树读取新建状态() {
	S_节点数据::G用于重新映射节点树到节点的容器.clear();
}



void f_node_加载节点(S_设备环境& ctx, std::vector<C_节点基类*>& m_Nodes, FILE* f) {
	std::map<std::wstring, C_节点基类*> 临时nodes;

	uint32 节点数量 = 0;
	fread(&节点数量, sizeof(uint32), 1, f);
	//std::vector<C_节点基类*> 临时序列nodes(节点数量);
	m_Nodes.resize(节点数量);
	auto* p_临时序列nodes = m_Nodes.data();

	
	for (uint32 i = 0; i < 节点数量; ++i) {
		std::string typeName = f_读取字符串(f);
		
		auto* loadFunc = g_节点加载函数[typeName];
		if (loadFunc) {
			auto* node = loadFunc(ctx, f);

			node->f_读取(f);

			临时nodes[node->f_getWName()] = node;
			p_临时序列nodes[i] = node;
		}
	}


	for (auto& e : m_Nodes) {
		if(e) e->f_读取插座(临时nodes, f);
		else std::cout<<"error: 读取插座 "<<e<<std::endl;
	}
	//重新链接插座
	for (auto& e : m_Nodes) {
		if(e) e->f_读取插座链接(f, 临时nodes);
		else std::cout<<"error: 读取插座链接 "<<e<<std::endl;
	}

	for (auto& e : m_Nodes) {
		if (e) e->f_构建附属节点(临时nodes);
	}
}

void f_node_保存节点(const std::set<C_节点基类*>& m_Nodes, FILE* f) {
	uint32 num = m_Nodes.size();
	fwrite(&num, sizeof(uint32), 1, f);

	for (auto& 节点 : m_Nodes) {
		f_file_保存字符串(f, 节点->m_TypeName);
		
		auto* saveFunc = g_节点保存函数[节点->m_TypeName];

		saveFunc(节点, f);
		节点->f_写入(f);
	}

	//从新构建节点插座
	for (auto& e : m_Nodes) {
		e->f_写入插座(f);
	}

	for (auto& e : m_Nodes) {
		e->f_写入插座链接(f);
	}
}

std::vector<C_节点树*> f_node_加载节点树(S_设备环境& ctx, FILE* f) {
	uint32 num = 0;

	auto 节点树文件块 = f_file_读取文件块(f);
	if (节点树文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_节点树) {
		const uint8* 下一次读取数据指针 = 节点树文件块.m_data;
		num = ((uint32*)下一次读取数据指针)[0];
	}
	free(节点树文件块.m_data);

	
	//fread(&num, sizeof(uint32), 1, f);
	
	std::vector<C_节点树*> trees(num);
	for (auto& t : trees) {
		auto 文件块 = f_file_读取文件块(f);
		if (文件块.m_块类型 != E_节点工程文件块类型::e_工程文件块_节点树属性) {
			free(文件块.m_data);
			continue;
		}
		const uint8* 下一次读取数据指针 = 文件块.m_data;

		std::wstring treeName;// = f_file_读取字符串(f);
		下一次读取数据指针 = f_解宽字符串(treeName, (uint8*)下一次读取数据指针);

		bool 是否为根节点树 = 下一次读取数据指针[0];
		下一次读取数据指针 = &下一次读取数据指针[1];
		//fread(&是否为根节点树, sizeof(bool), 1, f);

		E_节点树类型 节点树类型 = *(E_节点树类型*)下一次读取数据指针;
		下一次读取数据指针 = &(下一次读取数据指针[sizeof(E_节点树类型)]);
		//fread(&节点树类型, sizeof(E_节点树类型), 1, f);


		switch (节点树类型) {
		case E_节点树类型::e_type_物体节点树: {
			t = f_node_Create节点树(false, treeName);
			break;
		}
		case E_节点树类型::e_type_包节点树: {
			t = f_node_Create包节点树(false, treeName);
			break;
		}
		case E_节点树类型::e_type_材质节点树: {
			t = f_node_Create材质节点树(false, treeName);
			break;
		}
		case E_节点树类型::e_type_渲染节点树: {
			t = f_node_Create渲染节点树(false, treeName);
			break;
		}
		case E_节点树类型::e_type_几何节点树: {
			t = f_node_Create几何节点树(false, treeName);
			break;
		}
		case E_节点树类型::e_type_循环节点树: {
			t = f_node_Create循环节点树(false, treeName);
			break;
		}
		case E_节点树类型::e_type_函数节点树: {
			t = f_node_Create函数节点树(false, treeName);
			break;
		}
		case E_节点树类型::e_type_着色节点树: {
			t = f_node_Create着色节点树(false, treeName);
			break;
		}
		}

		下一次读取数据指针 = f_prop_Load(t->m_编译方式, 下一次读取数据指针);
		下一次读取数据指针 = f_prop_Load(t->m_函数名称, 下一次读取数据指针);
		下一次读取数据指针 = f_prop_Load(t->m_外部加载, 下一次读取数据指针);
		下一次读取数据指针 = f_prop_Load(t->m_代码文件路径, 下一次读取数据指针);
		free(文件块.m_data);

		f_prop_enum(t->m_编译方式) = E_JIT方式::e_jit_dll;


		S_节点数据::G用于重新映射节点树到节点的容器[treeName] = t;
		

		std::vector<C_节点基类*> 临时序列nodes;
		f_node_加载节点(ctx, 临时序列nodes, f);

		for (auto& e : 临时序列nodes) {
			if(e) t->f_添加节点(e);
			else std::cout<<"没有加载节点"<<std::endl;
		}

	}

	return trees;
}

void f_node_保存节点树(std::vector<C_节点树*>& trees, FILE* f) {
	uint32 num = trees.size();
	//fwrite(&num, sizeof(uint32), 1, f);
	auto 节点树文件块 = f_file_构建文件块信息(E_节点工程文件块类型::e_工程文件块_节点树, S_节点数据::g_文件版本号);
	S_UI8Array* 节点树属性块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));
	f_core_array_push_back_block((S_Array*)节点树属性块, (uint8*)&num, sizeof(uint32));

	节点树文件块.m_data = 节点树属性块->ptr_userData;
	节点树文件块.m_字节数 = 节点树属性块->count;
	f_file_保存文件块(f, 节点树文件块);
	f_core_array_free((S_Array*)节点树属性块);


	for (auto& t : trees) {
		auto 文件块 = f_file_构建文件块信息(E_节点工程文件块类型::e_工程文件块_节点树属性, S_节点数据::g_文件版本号);
		S_UI8Array* 块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));

		f_包宽字符串(块, t->m_IDName);
		
		bool 是否为根节点树 = !(t->m_节点树绑定的父节点.size());
		
		f_core_array_push_back_block((S_Array*)块, (uint8*)&是否为根节点树, sizeof(bool));
		f_core_array_push_back_block((S_Array*)块, (uint8*)&(t->m_树类型), sizeof(E_节点树类型));

		f_prop_Save(t->m_编译方式, 块);
		f_prop_Save(t->m_函数名称, 块);
		f_prop_Save(t->m_外部加载, 块);
		f_prop_Save(t->m_代码文件路径, 块);
		
		文件块.m_data = 块->ptr_userData;
		文件块.m_字节数 = 块->count;
		f_file_保存文件块(f, 文件块);
		f_core_array_free((S_Array*)块);


		f_node_保存节点(t->m_Nodes, f);
	}
}


void f_node后端_读取所有节点(S_设备环境& ctx, FILE* f) {
	
	f_node后端_销毁所有节点树();


	S_节点数据::G用于重新映射节点树到节点的容器.clear();
	S_节点数据::g_根节点树 = f_node_加载节点树(ctx, f);

	
	S_节点数据::G用于重新映射节点树到节点的容器.clear();
	S_节点数据::g_渲染根节点树 = f_node_加载节点树(ctx, f);


	for (auto& e : S_节点数据::g_物体节点树) {
		f_NT_预处理冻结节点((C_节点树*)e.m_Ptr);
	}
	
}

void f_node后端_写出所有节点(FILE* f) {
	f_node后端_所有节点树设置为准备保存状态();
	
	
	S_节点数据::G用于重新映射节点树到节点的容器.clear();
	f_node_保存节点树(S_节点数据::g_根节点树, f);
	
	
	S_节点数据::G用于重新映射节点树到节点的容器.clear();
	f_node_保存节点树(S_节点数据::g_渲染根节点树, f);
	
	
}


void f_node后端_保存库节点(const std::set<C_节点基类*>& m_Nodes, FILE* f) {
	auto 库节点文件块 = f_file_构建文件块信息(E_节点工程文件块类型::e_工程文件块_库节点, S_节点数据::g_文件版本号);
	S_UI8Array* 库节点块 = (S_UI8Array*)f_core_array_new(0, sizeof(uint8));

	f_包字符串(库节点块, (*m_Nodes.begin())->m_ICO);
	f_包字符串(库节点块, "库节点说明");

	库节点文件块.m_data = 库节点块->ptr_userData;
	库节点文件块.m_字节数 = 库节点块->count;
	f_file_保存文件块(f, 库节点文件块);
	f_core_array_free((S_Array*)库节点块);

	f_node_保存节点(m_Nodes, f);
}

void f_node后端_加载库节点(S_设备环境& ctx, std::vector<C_节点基类*>& Nodes, FILE* f) {
	std::string ICO_说明[2];

	if (f_node后端_加载库节点信息(ICO_说明, f)) {
		f_node_加载节点(ctx, Nodes, f);
	}

}

bool f_node后端_加载库节点信息(std::string info[2], FILE* f) {
	auto 文件块 = f_file_读取文件块(f);
	if (文件块.m_块类型 == E_节点工程文件块类型::e_工程文件块_库节点) {
		const uint8* 下一次读取数据指针 = 文件块.m_data;

		下一次读取数据指针 = f_解字符串(info[0], 下一次读取数据指针);
		下一次读取数据指针 = f_解字符串(info[1], 下一次读取数据指针);

		free(文件块.m_data);
		return true;
	}
	free(文件块.m_data);
	return false;
}

bool f_node后端_覆盖保存库节点(std::string path, const std::set<C_节点基类*>& m_Nodes) {
	//auto 文件路径 = f_file_get路径(path) + newName + ".node";

	if (f_file_文件是否存在(path)) {
		//std::filesystem::rename(path, 文件路径);
		auto f = fopen(path.c_str(), "wb");
		f_node后端_保存库节点(m_Nodes, f);
		fclose(f);
	}
	
	return true;
}



void f_node_视口拾取空间射线坐标(const vec3& 开始, const vec3& 结束) {
	C_射线拾取节点::m_视口空间坐标[0] = 开始;
	C_射线拾取节点::m_视口空间坐标[1] = 结束;

}

void f_NT_设置节点名称(C_节点基类* 节点, std::wstring name) {
	C_节点树::G节点名称分配.f_Move(节点->m_Name);
	节点->m_Name = C_节点树::G节点名称分配.f_Gen(name);
}

void f_NT_是否正在编译(){
	
}








/*void f_node_准备实时更新节点()
{
	for (auto& e : g根节点树) {
		uint32 num = e->m_层更新节点.size();
		if (!num) continue;

		//if (f_node_帧是否更新()) {
		for (auto& n : e->m_层更新节点[0]) {
			if (n->f_get更新方式() == E_节点更新方式::e_节点更新_实时) {
				n->f_set是否要更新(true);
			}
		}
		//}
	}
}*/


/*void f_node_Step节点数() {
	f_node_准备实时更新节点();

	for (auto& e : g根节点树) {
		e->f_准备Update();

		bool 是否中断 = false;
		uint32 num = e->m_层更新节点.size();
		for (uint32 i = 0; i < num; ++i) {
			是否中断 = e->f_Update(i);

			if (是否中断) {
				e->m_中断层 = i;
				break;
			}
		}

	}
}*/
